{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 肺部识别实战"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 加入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torchvision import datasets, transforms, utils, models\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard.writer import SummaryWriter\n",
    "import os\n",
    "import torchvision\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2 加载数据集\n",
    "\n",
    "# 2.1 图像变化设置\n",
    "data_transforms = {\n",
    "    \"train\":\n",
    "        transforms.Compose([\n",
    "            transforms.RandomResizedCrop(300), \n",
    "            transforms.RandomHorizontalFlip(), \n",
    "            transforms.CenterCrop(256),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                 [0.229, 0.224, 0.225])\n",
    "        ]),\n",
    "    \n",
    "    \"val\":\n",
    "        transforms.Compose([\n",
    "            transforms.Resize(300),\n",
    "            transforms.CenterCrop(256),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                 [0.229, 0.224, 0.225])\n",
    "        ]),\n",
    "    \n",
    "    'test':\n",
    "        transforms.Compose([\n",
    "        transforms.Resize(size=300),\n",
    "        transforms.CenterCrop(size=256),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224,\n",
    "        0.225])\n",
    "        ]),\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 可视化图片\n",
    "def imshow(inp, title=None):\n",
    "    inp = inp.numpy().transpose((1,2,0))\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    inp = std * inp + mean\n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    plt.imshow(inp)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.pause(0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6 可视化模型预测\n",
    "\n",
    "def visualize_model(model, num_images=6):\n",
    "    \"\"\"显示预测的图片结果\n",
    "        Args:\n",
    "            model: 训练后的模型\n",
    "            num_images: 需要显示的图片数量\n",
    "        \n",
    "        Returns:\n",
    "            无\n",
    "    \"\"\"\n",
    "    was_training = model.training\n",
    "    model.eval()\n",
    "    images_so_far = 0\n",
    "    fig = plt.figure()\n",
    "    with torch.no_grad():\n",
    "        for i, (datas, targets) in enumerate(dataloaders['val']):\n",
    "            datas, targets = datas.to(device), targets.to(device)\n",
    "            outputs = model(datas) # 预测数据\n",
    "            _, preds = torch.max(outputs, 1) # 获取每行数据的最大值\n",
    "            for j in range(datas.size()[0]):\n",
    "                images_so_far += 1 # 累计图片数量\n",
    "                ax = plt.subplot(num_images // 2, 2, images_so_far) # 显示图片\n",
    "                ax.axis('off') # 关闭坐标轴\n",
    "                ax.set_title('predicted:{}'.format(class_names[preds[j]]))\n",
    "                imshow(datas.cpu().data[j])\n",
    "                if images_so_far == num_images:\n",
    "                    model.train(mode=was_training)\n",
    "                    return\n",
    "        model.train(mode=was_training)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7 定义训练函数\n",
    "def train(model, device, train_loader, criterion, optimizer, epoch, writer):\n",
    "    # 作用：声明在模型训练时，采用Batch Normalization 和 Dropout\n",
    "    # Batch Normalization : 对网络中间的每层进行归一化处理，保证每层所提取的特征分布不会被破坏\n",
    "    # Dropout : 减少过拟合\n",
    "    model.train()\n",
    "    total_loss = 0.0 # 总损失初始化为0.0\n",
    "    # 循环读取训练数据，更新模型参数\n",
    "    for batch_id, (data, target) in enumerate(train_loader):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        optimizer.zero_grad() # 梯度初始化为零\n",
    "        output = model(data) # 训练后的输出\n",
    "        loss = criterion(output, target) # 计算损失\n",
    "        loss.backward() # 反向传播\n",
    "        optimizer.step() # 参数更新\n",
    "        total_loss += loss.item() # 累计损失\n",
    "    # 写入日志\n",
    "    writer.add_scalar('Train Loss', total_loss / len(train_loader), epoch)\n",
    "    writer.flush() # 刷新\n",
    "    return total_loss / len(train_loader) # 返回平均损失值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 8 定义测试函数\n",
    "def test(model, device, test_loader, criterion, epoch, writer):\n",
    "    # 作用：声明在模型训练时，不采用Batch Normalization 和 Dropout\n",
    "    model.eval()\n",
    "    # 损失和正确\n",
    "    total_loss = 0.0\n",
    "    correct = 0.0\n",
    "    # 循环读取数据\n",
    "    with torch.no_grad():\n",
    "        for data, target in test_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            # 预测输出\n",
    "            output = model(data)\n",
    "            # 计算损失\n",
    "            total_loss += criterion(output, target).item()\n",
    "            # 获取预测结果中每行数据概率最大的下标\n",
    "            _,preds = torch.max(output, dim=1) \n",
    "            # pred = output.data.max(1)[1]\n",
    "            # 累计预测正确的个数\n",
    "            correct += torch.sum(preds == target.data)\n",
    "            # correct += pred.eq(target.data).cpu().sum()\n",
    "            \n",
    "            ######## 增加 #######\n",
    "            misclassified_images(preds, writer, target, data, output, epoch) # 记录错误分类的图片\n",
    "            \n",
    "        # 总损失\n",
    "        total_loss /= len(test_loader)\n",
    "        # 正确率\n",
    "        accuracy = correct / len(test_loader.dataset)\n",
    "        # 写入日志\n",
    "        writer.add_scalar('Test Loss', total_loss, epoch)\n",
    "        writer.add_scalar('Accuracy', accuracy, epoch)\n",
    "        writer.flush()\n",
    "        # 输出信息\n",
    "        print(\"Test Loss : {:.4f}, Accuracy : {:.4f}\".format(total_loss, accuracy))\n",
    "        return total_loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义函数，获取Tensorboard的writer\n",
    "def tb_writer():\n",
    "    timestr = time.strftime(\"%Y%m%d_%H%M%S\")\n",
    "    writer = SummaryWriter('logdir/' + timestr)\n",
    "    return writer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 8 模型微调\n",
    "\n",
    "# 定义一个池化层处理函数\n",
    "class AdaptiveConcatPool2d(nn.Module):\n",
    "    def __init__(self, size=None):\n",
    "        super().__init__()\n",
    "        size = size or (3,3) # 池化层的卷积核大小，默认值为（3，3）\n",
    "        self.pool_one = nn.AdaptiveAvgPool2d(size) # 池化层1\n",
    "        self.pool_two = nn.AdaptiveMaxPool2d(size) # 池化层2\n",
    "    def forward(self, x):\n",
    "        return torch.cat([self.pool_one(x), self.pool_two(x)], 1) # 连接两个池化层\n",
    " \n",
    "def get_model():\n",
    "    model_pre = models.resnet50(pretrained=True) # 获取预训练模型\n",
    "\n",
    "    # 冻结预训练模型中所有参数\n",
    "    for param in model_pre.parameters():\n",
    "        param.requires_grad = False\n",
    "\n",
    "    # 替换ResNet最后的两层网络，返回一个新的模型（迁移学习）\n",
    "    model_pre.avgpool = AdaptiveConcatPool2d() # 池化层替换\n",
    "    model_pre.fc = nn.Sequential(\n",
    "            nn.Flatten(), # 所有维度拉平\n",
    "            # nn.BatchNorm1d(4096), # 正则化处理\n",
    "            nn.BatchNorm1d(36864), # 正则化处理\n",
    "            nn.Dropout(0.5), # 丢掉神经元\n",
    "            # nn.Linear(4096, 512), # 线性层处理\n",
    "            nn.Linear(36864, 512), # 线性层处理\n",
    "            nn.ReLU(), # 激活函数\n",
    "            nn.BatchNorm1d(512), # 正则化处理\n",
    "            nn.Dropout(p=0.5), # 丢掉神经元\n",
    "            nn.Linear(512, 2), # 线性层\n",
    "            nn.LogSoftmax(dim=1) # 损失函数\n",
    "    )\n",
    "    return model_pre\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epochs(model, device, dataloaders, criterion, optimizer, num_epochs, writer):\n",
    "    \"\"\"\n",
    "    Returns:\n",
    "        返回一个训练过后最好的模型\n",
    "    \"\"\"\n",
    "    print(\"{0:>20} | {1:>20} | {2:>20} | {3:>20} |\".format('Epoch', 'Training Loss', 'Test Loss', 'Accuracy'))\n",
    "    best_score = np.inf # 假设最好的预测值\n",
    "    start = time.time() # 开始时间\n",
    "    \n",
    "    # 开始循环读取数据进行训练和验证\n",
    "    for epoch in num_epochs:\n",
    "        \n",
    "        train_loss = train(model, device, dataloaders['train'], criterion, optimizer, epoch, writer)\n",
    "        \n",
    "        test_loss, accuracy = test(model, device, dataloaders['val'], criterion, epoch, writer)\n",
    "        \n",
    "        if test_loss < best_score:\n",
    "            best_score = test_loss\n",
    "            torch.save(model.state_dict(), model_path) # 保存模型 # state_dict变量存放训练过程中需要学习的权重和偏置系数\n",
    "        \n",
    "        print(\"{0:>20} | {1:>20} | {2:>20} | {3:>20.2f} |\".format(epoch, train_loss, test_loss, accuracy))\n",
    "        \n",
    "        writer.flush()\n",
    "        \n",
    "    # 训练完所耗费的总时间\n",
    "    time_all = time.time() - start\n",
    "    # 输出时间信息\n",
    "    print(\"Training complete in {:.2f}m {:.2f}s\".format(time_all // 60, time_all % 60))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def misclassified_images(pred, writer, target, data, output, epoch, count=10):\n",
    "    misclassified = (pred != target.data) # 记录预测值与真实值不同的True和False\n",
    "    for index, image_tensor in enumerate(data[misclassified][:count]):\n",
    "        # 显示预测不同的前10张图片\n",
    "        img_name = '{}->Predict-{}x{}-Actual'.format(\n",
    "                epoch,\n",
    "                LABEL[pred[misclassified].tolist()[index]],\n",
    "                LABEL[target.data[misclassified].tolist()[index]],\n",
    "        )\n",
    "        writer.add_image(img_name, inv_normalize(image_tensor), epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Epoch |        Training Loss |            Test Loss |             Accuracy |\n",
      "Test Loss : 0.7482, Accuracy : 0.7500\n",
      "                   0 |  0.37546360227437947 |   0.7481886744499207 |                 0.75 |\n",
      "Test Loss : 0.4785, Accuracy : 0.8125\n",
      "                   1 |  0.26250585539975774 |   0.4785425364971161 |                 0.81 |\n",
      "Test Loss : 0.6143, Accuracy : 0.8125\n",
      "                   2 |  0.24647439648354016 |    0.614277184009552 |                 0.81 |\n",
      "Test Loss : 0.4550, Accuracy : 0.8750\n",
      "                   3 |  0.22980742459834175 |  0.45500850677490234 |                 0.88 |\n",
      "Test Loss : 0.4762, Accuracy : 0.8750\n",
      "                   4 |  0.22832605980867202 |  0.47616851329803467 |                 0.88 |\n",
      "Test Loss : 0.5090, Accuracy : 0.8125\n",
      "                   5 |  0.22127203448984092 |   0.5090200304985046 |                 0.81 |\n",
      "Test Loss : 0.5329, Accuracy : 0.8125\n",
      "                   6 |   0.2200799149982977 |   0.5329417586326599 |                 0.81 |\n",
      "Test Loss : 0.7185, Accuracy : 0.8125\n",
      "                   7 |  0.20401323301827207 |   0.7185251116752625 |                 0.81 |\n",
      "Test Loss : 0.6448, Accuracy : 0.7500\n",
      "                   8 |  0.21905418684930994 |   0.6448410749435425 |                 0.75 |\n",
      "Test Loss : 0.6633, Accuracy : 0.7500\n",
      "                   9 |   0.2127879018557976 |   0.6633487343788147 |                 0.75 |\n",
      "Training complete in 20.00m 12.74s\n"
     ]
    }
   ],
   "source": [
    "# 9 训练和验证\n",
    "\n",
    "# 定义超参数\n",
    "model_path = 'model.pth'\n",
    "batch_size = 16\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # gpu和cpu选择\n",
    "\n",
    "# 2.2 加载数据\n",
    "data_path = \"chest_xray\" # 数据集所在的文件夹路径\n",
    "\n",
    "# 2.2.1 加载数据集\n",
    "image_datasets = {x : datasets.ImageFolder(os.path.join(data_path, x), data_transforms[x]) for x in ['train', 'val', 'test']}\n",
    "\n",
    "# 2.2.2 为数据集创建iterator\n",
    "dataloaders = {x : DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True) for x in ['train', 'val', 'test']}\n",
    "\n",
    "# 2.2.3 训练集和验证集的大小\n",
    "data_sizes = {x : len(image_datasets[x]) for x in ['train', 'val', 'test']}\n",
    "\n",
    "# 2.2.4 训练集所对应的标签\n",
    "class_names = image_datasets['train'].classes # 一共有2个：NORMAL正常 vs PNEUMONIA肺炎\n",
    "LABEL = dict((v, k ) for k, v in image_datasets['train'].class_to_idx.items())\n",
    "\n",
    "print(\"-\" * 50)\n",
    "\n",
    "# 4 获取trian中的一批数据\n",
    "datas, targets = next(iter(dataloaders['train']))\n",
    "\n",
    "# 5 显示这批数据\n",
    "out = torchvision.utils.make_grid(datas)\n",
    "\n",
    "imshow(out, title=[class_names[x] for x in targets])\n",
    "\n",
    "# 将tensor转换为image\n",
    "inv_normalize = transforms.Normalize(\n",
    "mean=[-0.485/0.229, -0.456/0.224, -0.406/0.225],\n",
    "std=[1/0.229, 1/0.224, 1/0.255]\n",
    ")\n",
    "\n",
    "writer = tb_writer()\n",
    "images, labels = next(iter(dataloaders['train'])) # 获取一批数据\n",
    "grid = torchvision.utils.make_grid([inv_normalize(image) for image in images[:32]]) # 读取32张图片\n",
    "writer.add_image('X-Ray grid', grid, 0) # 添加到TensorBoard\n",
    "writer.flush() # 将数据读取到存储器中\n",
    "\n",
    "model = get_model().to(device) # 获取模型\n",
    "# criterion = nn.NLLLoss() # 损失函数\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "train_epochs(model, device, dataloaders, criterion, optimizer, range(0,10), writer)\n",
    "writer.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myconda",
   "language": "python",
   "name": "myconda"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
